package com.xuecheng.content.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.xuecheng.api.content.model.dto.TeachplanDTO;
import com.xuecheng.api.content.model.dto.TeachplanMediaDTO;
import com.xuecheng.api.media.model.dto.MediaDTO;
import com.xuecheng.common.domain.code.CommonErrorCode;
import com.xuecheng.common.domain.response.RestResponse;
import com.xuecheng.common.enums.common.AuditEnum;
import com.xuecheng.common.enums.common.CommonEnum;
import com.xuecheng.common.enums.content.CourseAuditEnum;
import com.xuecheng.common.enums.content.CourseModeEnum;
import com.xuecheng.common.enums.content.TeachPlanEnum;
import com.xuecheng.common.exception.ExceptionCast;
import com.xuecheng.common.util.StringUtil;
import com.xuecheng.content.agent.MediaApiAgent;
import com.xuecheng.content.common.constant.ContentErrorCode;
import com.xuecheng.content.convert.TeachplanConvert;
import com.xuecheng.content.convert.TeachplanMediaConvert;
import com.xuecheng.content.entity.CourseBase;
import com.xuecheng.content.entity.Teachplan;
import com.xuecheng.content.entity.TeachplanMedia;
import com.xuecheng.content.entity.ext.TeachplanNode;
import com.xuecheng.content.mapper.TeachplanMapper;
import com.xuecheng.content.service.CourseBaseService;
import com.xuecheng.content.service.TeachplanMediaService;
import com.xuecheng.content.service.TeachplanService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils;
import org.springframework.util.ObjectUtils;

import java.util.ArrayList;
import java.util.List;

/**
 * <p>
 * 课程计划 服务实现类
 * </p>
 *
 * @author itcast
 */
@Slf4j
@Service
public class TeachplanServiceImpl extends ServiceImpl<TeachplanMapper, Teachplan> implements TeachplanService {


    @Autowired
    private CourseBaseService courseBaseService;

    @Autowired
    private TeachplanMediaService teachplanMediaService;

    @Autowired
    private MediaApiAgent mediaApiAgent;


    /**
     * 根据课程id查询课程计划的树形结构，即三级目录
     *
     * @param courseId  课程id
     * @param companyId 公司id
     * @return com.xuecheng.api.content.model.dto.TeachplanDTO
     * @author Lily
     * @date 2021/12/12 20:02
     * @paramType [java.lang.Long, java.lang.Long]
     * @description 业务分析
     * 1.判断关键数据
     * 1-1.课程id和公司id是否为空
     * <p>
     * 2.判断业务数据
     * 2-1.课程基本信息  判断是否存在、判断是否是同一家机构、判断是否删除
     * <p>
     * 3.根据courseId查询课程计划数据
     * <p>
     * 4.通过java递归生成课程属性结构
     * <p>
     * 5.将数据转成dto并保存
     */
    @Override
    public TeachplanDTO queryTreeNodesByCourseId(Long courseId, Long companyId) {

        // 1.判断关键数据
        // 1-1.课程id和公司id是否为空
        if (ObjectUtils.isEmpty(companyId) ||
                ObjectUtils.isEmpty(courseId)
        ) {
            ExceptionCast.cast(CommonErrorCode.E_100101);
        }

        // 2.判断业务数据
        // 2-1.课程基本信息  判断是否存在、判断是否是同一家机构、判断是否删除，这里查询的是课程信息
        // 判断是否存在、判断是否是同一家机构
        LambdaQueryWrapper<CourseBase> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(CourseBase::getId, courseId);
        queryWrapper.eq(CourseBase::getCompanyId, companyId);
        CourseBase courseBase = courseBaseService.getOne(queryWrapper);
        if (ObjectUtils.isEmpty(courseBase)) {
            ExceptionCast.cast(ContentErrorCode.E_120013);
        }
        // 判断是否删除
        Integer status = courseBase.getStatus();
        if (CommonEnum.DELETE_FLAG.getCodeInt().equals(status)) {
            ExceptionCast.cast(ContentErrorCode.E_120021);
        }

        // 3.根据courseId查询课程计划数据
        // TODO 啥意思？    获取当DAO对象，然后调用其中的方法
        TeachplanMapper baseMapper = this.getBaseMapper();
        List<TeachplanNode> nodes = baseMapper.selectByCourseId(courseId);

        // 4.通过java递归生成课程属性结构
        // TODO 为什么提取出来？    如果不提取，则if中的无法使用，需要写两次转dto
        TeachplanDTO teachplanDTO = null;
        if (CollectionUtils.isEmpty(nodes)) {
            teachplanDTO = new TeachplanDTO();
        } else {
            TeachplanNode rootNode = nodes.remove(0);
            generateTreeNodes(rootNode, nodes);

            // 5.将数据转成dto并保存
            teachplanDTO = TeachplanConvert.INSTANCE.entity2dto(rootNode);
        }

        return teachplanDTO;
    }


    private void generateTreeNodes(TeachplanNode rootNode, List<TeachplanNode> nodes) {

        // 1.判断父级是否为空，即第一次添加时
        if (ObjectUtils.isEmpty(rootNode.getChildrenNodes())) {
            // TODO 如果是第一次遍历，则创建子节点，并设置空集合
            rootNode.setChildrenNodes(new ArrayList<>());
        }

        // 2.循环遍历生成树结构
        for (TeachplanNode node : nodes) {

            // 2-1.判断node是否和parentnode有关联，如果有关联将node存放到parentNode集合中
            //ObjectUtils工具类的nullSafeEquals方法可以完全避免空指针问题，null和null比较的结果为true。
            if (ObjectUtils.nullSafeEquals(node.getParentid(), rootNode.getId())) {

                // 2-2.生成node集合数据
                rootNode.getChildrenNodes().add(node);

                // 2-3.如果是第3级则无需递归
                if (!(TeachPlanEnum.THIRD_LEVEL.equals(node.getGrade()))) {
                    generateTreeNodes(node, nodes);
                }
            }
        }
    }


    /**
     * 创建或修改教学计划
     *
     * @param teachplanDTO 前端传递的数据
     * @param companyId    公司id
     * @return com.xuecheng.api.content.model.dto.TeachplanDTO
     * @author Lily
     * @date 2021/12/12 21:51
     * @paramType [com.xuecheng.api.content.model.vo.TeachplanVO]
     * @description 业务分析：修改和添加的区别在于是否有id
     * 1.TeachplanDTO 中的 Id 不为空并且在数据库中存在此 Id 数据，进行修改操作。
     * 2.TeachplanDTO 中的 为空，进行添加操作。
     * <p>
     * 主体方法：
     * 1.判断业务操作
     * 1-1.判断是修改还是新增：teachplanId，有则修改，无则创建
     * <p>
     * 2.执行创建和修改，并返回dto
     */
    @Transactional
    @Override
    public TeachplanDTO createOrModifyTeachPlan(TeachplanDTO teachplanDTO, Long companyId) {

        TeachplanDTO resultDTO = null;

        // 1.判断业务操作
        // 1-1.判断是修改还是新增：teachplanId，有则修改，无则创建
        if (ObjectUtils.isEmpty(teachplanDTO.getTeachPlanId())) {
            resultDTO = createTeachplan(teachplanDTO, companyId);
        } else {
            resultDTO = modifyTeachplan(teachplanDTO, companyId);
        }

        // 2.执行创建和修改，并返回dto
        return resultDTO;
    }


    /**
     * 创建teachplan
     *
     * @param teachplanDTO 前端传递的数据
     * @param companyId    公司id
     * @return com.xuecheng.api.content.model.dto.TeachplanDTO
     * @author Lily
     * @date 2021/12/12 22:14
     * @paramType [com.xuecheng.api.content.model.dto.TeachplanDTO, java.lang.Long]
     * @description 业务分析：
     * 1.判断关键数据
     * <p>
     * 2.判断业务数据
     * 2-1.课程基础信息：是否存在、同一家公司、是否删除、审核状态（未提交和审核未通过）
     * <p>
     * 3.获得父级数据并关联：parentId、grade、orderBy（bug）
     * <p>
     * 4.将dto转po并保存
     * <p>
     * 5.判断保存后的结果
     * <p>
     * 6.将数据库最新数据转成dto并返回
     */
    private TeachplanDTO createTeachplan(TeachplanDTO teachplanDTO, Long companyId) {

        // 1.判断关键数据
        // 2.判断业务数据
        // 2-1.课程基础信息：是否存在、同一家公司、是否删除、审核状态（未提交和审核未通过）
        CourseBase courseBase = verifyTeachplanMsg(teachplanDTO, companyId);

        // 2-2.判断是否有数据
        if (ObjectUtils.isEmpty(courseBase)) {
            ExceptionCast.cast(CommonErrorCode.E_100101);
        }

        // 3.获得父级数据并关联：parentId、grade、orderBy（bug）
        Teachplan teachplan = TeachplanConvert.INSTANCE.dto2entity(teachplanDTO);

        // TODO 获取父级，并把父级的数据取出来关联
        Teachplan parentNode = generateParentNode(teachplanDTO, courseBase);

        // 设置子的parentId
        teachplan.setParentid(parentNode.getId());
        // 设置子的等级
        teachplan.setGrade(parentNode.getGrade() + 1);
        // 设置orderBy排序，要先查询父目前有多少个子，在此基础上+1，但是有bug，并发
        LambdaQueryWrapper<Teachplan> queryWrapper = new LambdaQueryWrapper<>();
        // 查询所有和id和该子的父id相同的数量
        queryWrapper.eq(Teachplan::getParentid, parentNode.getId());
        int count = this.count(queryWrapper);
        teachplan.setOrderby(count + 1);

        // 4.将dto转的po保存
        boolean save = this.save(teachplan);

        // 5.判断保存后的结果
        if (!save) {
            ExceptionCast.cast(ContentErrorCode.E_120407);
        }

        // 6.将数据库最新数据转成dto并返回
        Teachplan po = this.getById(teachplan.getId());
        TeachplanDTO dto = TeachplanConvert.INSTANCE.entity2dto(po);

        return dto;
    }


    /**
     * 生成父节点
     *
     * @param teachplanDTO 课程计划dto
     * @param courseBase   课程基础
     * @return {@link Teachplan}
     */
    private Teachplan generateParentNode(TeachplanDTO teachplanDTO, CourseBase courseBase) {

        //1.判断新增数据是二级还是三级课程计划
        //     判断新增数据是否有parentId值
        //         如果有：三级课程计划
        //         如果没有：二级课程计划
        Long parentid = teachplanDTO.getParentid();
        if (ObjectUtils.isEmpty(parentid)) {

            // 为空，说明是二级目录
            // 2.获得二级课程计划的父级数据
            //     查询数据库获得一级课程计划：courseId、parentid=0
            //         如果没有：自动创建并保存数据--数据来源 coursebase
            //         如果有：直接返回
            LambdaQueryWrapper<Teachplan> queryWrapper = new LambdaQueryWrapper<>();
            queryWrapper.eq(Teachplan::getCourseId, courseBase.getId());
            queryWrapper.eq(Teachplan::getParentid, TeachPlanEnum.FIRST_PARENTID_FLAG);

            // 如果有则直接返回
            Teachplan rootParent = this.getOne(queryWrapper);

            // 如果没有父级则创建
            if (ObjectUtils.isEmpty(rootParent)) {
                rootParent = new Teachplan();

                // 赋值
                rootParent.setPname(courseBase.getName());
                rootParent.setParentid(new Long(TeachPlanEnum.FIRST_PARENTID_FLAG));
                rootParent.setGrade(TeachPlanEnum.FIRST_LEVEL);
                rootParent.setDescription(courseBase.getDescription());
                rootParent.setOrderby(TeachPlanEnum.FIRST_LEVEL);
                rootParent.setCourseId(courseBase.getId());

                // 保存
                boolean save = this.save(rootParent);

                // 如果创建失败报错
                if (!save) {
                    ExceptionCast.cast(ContentErrorCode.E_120407);
                }
            }

            // 返回父级
            return rootParent;
        } else {

            // 不为空，则为三级目录
            // 3.获得三级课程计划的父级数据
            //     查询数据库获得二级课程计划：parentId
            //         如果没有：直接抛出异常
            //         如果有：直接返回
            LambdaQueryWrapper<Teachplan> queryWrapper = new LambdaQueryWrapper<>();
            // TODO 这里是3级目录的父级，所以要获取id
            queryWrapper.eq(Teachplan::getId, parentid);
            Teachplan teachplan = this.getOne(queryWrapper);

            // 判断是否存在
            if (ObjectUtils.isEmpty(teachplan)) {

                // 父级没有抛异常
                ExceptionCast.cast(ContentErrorCode.E_120408);
            }
            return teachplan;
        }
    }

    private CourseBase verifyTeachplanMsg(TeachplanDTO teachplanDTO, Long companyId) {

        // 1.判断关键数据
        // 公司id，课程基本内容id，课程名称是否为空
        if (ObjectUtils.isEmpty(companyId) ||
                StringUtil.isBlank(teachplanDTO.getPname()) ||
                ObjectUtils.isEmpty(teachplanDTO.getCourseId())
        ) {
            ExceptionCast.cast(CommonErrorCode.E_100101);
        }

        // 2.判断业务数据
        // 2-1.课程基础信息：是否存在、同一家公司、是否删除、审核状态（未提交和审核未通过）
        // 获取课程的审核审核状态
        CourseBase courseBase = courseBaseService.getCourseBaseById(teachplanDTO.getCourseId(), companyId);

        // 返回查询结果
        return courseBase;
    }


    /**
     * 修改teachplan
     *
     * @param teachplanDTO 前端传递的数据
     * @param companyId    公司id
     * @return com.xuecheng.api.content.model.dto.TeachplanDTO
     * @author Lily
     * @date 2021/12/12 22:14
     * @paramType [com.xuecheng.api.content.model.dto.TeachplanDTO, java.lang.Long]
     * @description
     */
    private TeachplanDTO modifyTeachplan(TeachplanDTO teachplanDTO, Long companyId) {

        // 1.判断关键数据
        // 2.判断业务数据
        //      课程基础信息
        //          判断是否存在
        //          判断是否同一家机构
        //          判断是否删除
        //          判断课程基础信息审核状态：未提交和审核未通过
        verifyTeachplanMsg(teachplanDTO, companyId);

        //      课程计划
        //          判断是否存在
        LambdaQueryWrapper<Teachplan> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(Teachplan::getId, teachplanDTO.getTeachPlanId());
        int count = this.count(queryWrapper);
        if (count < 1) {
            ExceptionCast.cast(ContentErrorCode.E_120402);
        }

        //  3.修改课程计划数据
        //       pname starttime endtime is_preview，只有这几个数据可以更改
        LambdaUpdateWrapper<Teachplan> updateWrapper = new LambdaUpdateWrapper<>();
        updateWrapper.set(Teachplan::getPname, teachplanDTO.getPname());
        updateWrapper.set(Teachplan::getStartTime, teachplanDTO.getStartTime());
        updateWrapper.set(Teachplan::getEndTime, teachplanDTO.getEndTime());
        updateWrapper.set(Teachplan::getIsPreview, teachplanDTO.getIsPreview());

        // 修改条件
        updateWrapper.eq(Teachplan::getId, teachplanDTO.getTeachPlanId());

        // 4.判断修改的结果
        boolean UpdateResult = this.update(updateWrapper);
        if (!UpdateResult) {
            ExceptionCast.cast(ContentErrorCode.E_120407);
        }

        // 5.将数据库最新的数据转为dto并返回
        Teachplan po = this.getById(teachplanDTO.getTeachPlanId());
        TeachplanDTO dto = TeachplanConvert.INSTANCE.entity2dto(po);

        return dto;
    }


    /**
     * 删除教学计划
     *
     * @param teachPlanId 教学计划id
     * @param companyId   公司id标识
     * @author Lily
     * @date 2021/12/13 10:38
     * @paramType [java.lang.Long, java.lang.Long]
     * @description 业务分析：
     * 1.判断关键数据的合法性
     * 1-1.是否存在、公司id
     * <p>
     * 2.根据课程计划等级进行业务判断
     * 2-1.判断二级课程计划是否有子级课程计划信息
     * 2-2.判断三级课程计划是否关联课程媒资信息
     * <p>
     * 3.根据Id删除课程计划
     */
    @Transactional
    @Override
    public void removeTeachPlan(Long teachPlanId, Long companyId) {

        // 1.判断关键数据的合法性
        // 1-1.课程计划是否存在、课程基础信息是否存在、公司id
        // 课程计划是否存在
        Teachplan teachplan = this.getById(teachPlanId);
        if (ObjectUtils.isEmpty(teachplan)) {
            ExceptionCast.cast(ContentErrorCode.E_120402);
        }

        // 课程基础信息是否存在
        CourseBase courseBase = courseBaseService.getById(teachplan.getCourseId());
        if (ObjectUtils.isEmpty(courseBase)) {
            ExceptionCast.cast(ContentErrorCode.E_120013);
        }

        // 判断公司id是否相同
        if (!(ObjectUtils.nullSafeEquals(courseBase.getCompanyId(), companyId))) {
            ExceptionCast.cast(CommonErrorCode.E_100108);
        }

        // 2.根据课程计划等级进行业务判断
        if (teachplan.getGrade().equals(TeachPlanEnum.SECEND_LEVEL)) {

            // 2-1.判断二级课程计划是否有子级课程计划信息
            LambdaQueryWrapper<Teachplan> queryWrapper = new LambdaQueryWrapper<>();

            // 判断是否是别的计划的父id
            queryWrapper.eq(Teachplan::getParentid, teachPlanId);
            int count = this.count(queryWrapper);
            if (count > 0) {

                // 如果是则不能删除
                ExceptionCast.cast(ContentErrorCode.E_120409);
            }
        } else {

            // 2-2.判断三级课程计划是否关联课程媒资信息
            LambdaQueryWrapper<TeachplanMedia> queryWrapper = new LambdaQueryWrapper<>();
            queryWrapper.eq(TeachplanMedia::getTeachplanId, teachPlanId);
            int count = teachplanMediaService.count(queryWrapper);
            if (count > 0) {
                ExceptionCast.cast(ContentErrorCode.E_120413);
            }
        }

        // 3.根据Id删除课程计划
        this.removeById(teachPlanId);
    }


    /**
     * @param dto
     * @param companyId
     * @return com.xuecheng.api.content.model.dto.TeachplanMediaDTO
     * @author Lily
     * @date 2021/12/20 23:38
     * @paramType [com.xuecheng.api.content.model.vo.BindTeachplanMediaVO, java.lang.Long]
     * @description 课程计划服务类
     * 业务分析：
     * 1.判断关键数据
     * teachplanId   mediaId
     * 2.判断业务数据
     * 课程计划数据
     * 判断是否存在
     * 判断是否是第三级
     * 判断课程类型是否为点播
     * 判断是否为同一家机构
     * 根据课程基础信息来查询
     * 媒资数据
     * 判断是否存在
     * 判断是否为同一家机构
     * 判断媒资信息是否审核通过
     * 3.保存课程计划和媒资信息关联关系
     * 判断关联数据是否存在
     * 不存在
     * 创建数据
     * 存在
     * 修改数据
     * mediaId 和 mediaName
     * 4.将数据封装成dto返回
     */
    @Override
    @Transactional
    public TeachplanMediaDTO associateMedia(TeachplanMediaDTO dto, Long companyId) {

        // 1.判断关键数据
        //   teachplanId   mediaId
        if (ObjectUtils.isEmpty(dto.getTeachplanId()) ||
                ObjectUtils.isEmpty(dto.getMediaId())
        ) {
            ExceptionCast.cast(CommonErrorCode.E_100101);
        }
        // 2.判断业务数据
        //   课程计划数据
        //     判断是否存在
        //     判断是否是第三级
        LambdaQueryWrapper<Teachplan> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(Teachplan::getId, dto.getTeachplanId());
        queryWrapper.eq(Teachplan::getGrade, TeachPlanEnum.THIRD_LEVEL);
        Teachplan teachplan = this.getOne(queryWrapper);
        if (ObjectUtils.isEmpty(teachplan)) {
            ExceptionCast.cast(CommonErrorCode.E_100104);
        }
        //     判断课程类型是否为点播
        //     判断是否为同一家机构
        //       根据课程基础信息来查询
        LambdaQueryWrapper<CourseBase> baseQueryWrapper = new LambdaQueryWrapper<>();
        baseQueryWrapper.eq(CourseBase::getId, teachplan.getCourseId());
        baseQueryWrapper.eq(CourseBase::getTeachmode, CourseModeEnum.COURSE_MODE_RECORD_STATUS.getCode());
        baseQueryWrapper.eq(CourseBase::getStatus, CommonEnum.USING_FLAG.getCodeInt());
        CourseBase courseBase = courseBaseService.getOne(baseQueryWrapper);
        if (ObjectUtils.isEmpty(courseBase)) {
            ExceptionCast.cast(CommonErrorCode.E_100104);
        }
        // 判断课程审核状态：只能为 未提交、审核未通过
        String auditStatus = courseBase.getAuditStatus();
        if (CourseAuditEnum.AUDIT_PASTED_STATUS.getCode().equals(auditStatus) ||
                CourseAuditEnum.AUDIT_COMMIT_STATUS.getCode().equals(auditStatus) ||
                CourseAuditEnum.AUDIT_PUBLISHED_STATUS.getCode().equals(auditStatus)
        ) {
            ExceptionCast.cast(ContentErrorCode.E_120015);
        }

        //   媒资数据
        //     判断是否存在
        RestResponse<MediaDTO> restResponse = mediaApiAgent.getById(dto.getMediaId());
        if (!(restResponse.isSuccessful())) {
            ExceptionCast.castWithCodeAndDesc(restResponse.getCode(), restResponse.getMsg());
        }
        //     判断是否为同一家机构
        MediaDTO mediaDTO = restResponse.getResult();
        if (!ObjectUtils.nullSafeEquals(mediaDTO.getCompanyId(), companyId)) {
            ExceptionCast.cast(CommonErrorCode.E_100108);
        }
        //     判断媒资信息是否审核通
        String mediaDTOAuditStatus = mediaDTO.getAuditStatus();
        if (!(AuditEnum.AUDIT_PASTED_STATUS.getCode().equals(mediaDTOAuditStatus))) {
            ExceptionCast.cast(ContentErrorCode.E_120015);
        }

        // 3.保存课程计划和媒资信息关联关系
        //   判断关联数据是否存在
        LambdaQueryWrapper<TeachplanMedia> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(TeachplanMedia::getTeachplanId, teachplan.getId());
        wrapper.eq(TeachplanMedia::getCourseId, teachplan.getCourseId());
        int count = teachplanMediaService.count(wrapper);
        boolean result = false;
        //     不存在
        //       创建数据
        if (count < 1) {
            TeachplanMedia teachplanMedia = new TeachplanMedia();
            teachplanMedia.setMediaId(mediaDTO.getId());
            teachplanMedia.setTeachplanId(teachplan.getId());
            teachplanMedia.setCourseId(teachplan.getCourseId());
            teachplanMedia.setMediaFilename(mediaDTO.getFilename());

            result = teachplanMediaService.save(teachplanMedia);
        }else {
        //     存在
        //       修改数据
        //         mediaId 和 mediaName
            LambdaUpdateWrapper<TeachplanMedia> updateWrapper = new LambdaUpdateWrapper<>();
            updateWrapper.set(TeachplanMedia::getMediaId, mediaDTO.getId());
            updateWrapper.set(TeachplanMedia::getMediaFilename, mediaDTO.getFilename());
            updateWrapper.eq(TeachplanMedia::getTeachplanId, teachplan.getId());
            result = teachplanMediaService.update(updateWrapper);
        }
        if (!result){
            ExceptionCast.cast(ContentErrorCode.E_120411);
        }

        // 4.将数据封装成dto返回
        LambdaQueryWrapper<TeachplanMedia> queryWrapper1 = new LambdaQueryWrapper<>();
        queryWrapper1.eq(TeachplanMedia::getTeachplanId, teachplan.getId());
        TeachplanMedia teachplanMedia = teachplanMediaService.getOne(queryWrapper1);
        TeachplanMediaDTO teachplanMediaDTO = TeachplanMediaConvert.INSTANCE.entity2dto(teachplanMedia);

        return teachplanMediaDTO;
    }

}
